package com.ruoyi.learn.java.design.pattern.behavior;

/**
 * 责任链模式 (Chain of Responsibility Pattern) 完整示例
 * 模拟一个报销审批流程。
 */
public class ChainOfResponsibilityDemo {

    // 1. 定义处理者抽象类 (Handler)
    public abstract static class Approver {
        protected Approver nextApprover; // 指向链中的下一个处理者
        protected String name;

        public Approver(String name) {
            this.name = name;
        }

        // 设置下一个处理者
        public void setNextApprover(Approver nextApprover) {
            this.nextApprover = nextApprover;
        }

        // 处理请求的抽象方法
        public abstract void processRequest(ExpenseRequest request);
    }

    // 2. 具体处理者 1: 主管 (Manager)
    public static class Manager extends Approver {
        public Manager(String name) {
            super(name);
        }

        @Override
        public void processRequest(ExpenseRequest request) {
            if (request.getAmount() < 1000) {
                System.out.println(name + " (主管) 批准了报销申请: " + request.getPurpose() + " - ¥" + request.getAmount());
            } else {
                // 无法处理，转发给下一个处理者
                if (nextApprover != null) {
                    System.out.println(name + " (主管) 无法处理 ¥" + request.getAmount() + " 的申请，转交给 " + nextApprover.name);
                    nextApprover.processRequest(request);
                } else {
                    System.out.println("没有更高级别的审批人可以处理 ¥" + request.getAmount() + " 的申请。");
                }
            }
        }
    }

    // 3. 具体处理者 2: 部门经理 (Director)
    public static class Director extends Approver {
        public Director(String name) {
            super(name);
        }

        @Override
        public void processRequest(ExpenseRequest request) {
            if (request.getAmount() >= 1000 && request.getAmount() <= 5000) {
                System.out.println(name + " (部门经理) 批准了报销申请: " + request.getPurpose() + " - ¥" + request.getAmount());
            } else {
                if (nextApprover != null) {
                    System.out.println(name + " (部门经理) 无法处理 ¥" + request.getAmount() + " 的申请，转交给 " + nextApprover.name);
                    nextApprover.processRequest(request);
                } else {
                    System.out.println("没有更高级别的审批人可以处理 ¥" + request.getAmount() + " 的申请。");
                }
            }
        }
    }

    // 4. 具体处理者 3: CEO
    public static class CEO extends Approver {
        public CEO(String name) {
            super(name);
        }

        @Override
        public void processRequest(ExpenseRequest request) {
            if (request.getAmount() > 5000) {
                System.out.println(name + " (CEO) 批准了报销申请: " + request.getPurpose() + " - ¥" + request.getAmount());
            } else {
                // 理论上，CEO 可以批准任何金额，但为了演示，我们假设只处理大于 5000 的
                // 如果金额小于等于5000，理论上应该由下级处理，但CEO收到了，说明链式传递可能有问题
                // 实际应用中，CEO 可能会处理所有请求，或者只处理特定请求。
                // 这里为了简单，我们让 CEO 只处理 >5000 的，否则说明流程设计有误。
                System.out.println(name + " (CEO) 收到了一个本应由下级处理的申请: " + request.getPurpose() + " - ¥" + request.getAmount());
                // 通常，CEO 可以批准，但这里我们选择不处理（或可以批准）
                // 为了演示，我们选择批准所有到达 CEO 的请求
                System.out.println(name + " (CEO) 最终批准了报销申请: " + request.getPurpose() + " - ¥" + request.getAmount());
            }
        }
    }

    // 5. 请求类: 报销申请
    public static class ExpenseRequest {
        private String purpose; // 报销事由
        private double amount;  // 报销金额

        public ExpenseRequest(String purpose, double amount) {
            this.purpose = purpose;
            this.amount = amount;
        }

        public String getPurpose() {
            return purpose;
        }

        public double getAmount() {
            return amount;
        }

        @Override
        public String toString() {
            return "报销申请 [事由: " + purpose + ", 金额: ¥" + amount + "]";
        }
    }

    // 6. 客户端类 (演示)
    public static class Client {
        private Approver firstApprover; // 链的起点

        public Client(Approver firstApprover) {
            this.firstApprover = firstApprover;
        }

        public void sendRequest(ExpenseRequest request) {
            System.out.println("发起报销申请: " + request);
            firstApprover.processRequest(request);
            System.out.println("---");
        }
    }

    // 7. 主方法 (程序入口)
    public static void main(String[] args) {
        // 创建具体处理者
        Manager manager = new Manager("张三");
        Director director = new Director("李四");
        CEO ceo = new CEO("王五");

        // 构建责任链: Manager -> Director -> CEO
        manager.setNextApprover(director);
        director.setNextApprover(ceo);
        // CEO 是链尾，nextApprover 为 null

        // 创建客户端，传入链的起点
        Client client = new Client(manager);

        // 发送不同金额的报销请求
        client.sendRequest(new ExpenseRequest("购买办公用品", 800.0));
        client.sendRequest(new ExpenseRequest("团队建设聚餐", 3500.0));
        client.sendRequest(new ExpenseRequest("参加国际技术大会", 8000.0));
        client.sendRequest(new ExpenseRequest("购买新服务器", 15000.0));

        // 测试一个无法被任何处理者处理的请求（如果链不完整）
        // 例如，如果只创建了 manager，没有设置 nextApprover
        // Manager simpleManager = new Manager("赵六");
        // Client simpleClient = new Client(simpleManager);
        // simpleClient.sendRequest(new ExpenseRequest("出差机票", 6000.0)); // 会提示没有更高级别审批人
    }
}